C++结构体

梦想不会自己发光，真正闪耀的是那个为梦狂奔的你。献给知行的孩子们！（Eric.He著）

本教程将从 C++ 结构体的特性、定义、使用到进阶技巧，全面拆解 C++ 结构体的核心用法，帮助你掌握这一基础且重要的编程工具。

教程目录导航

▼

一、C++ 结构体的核心概述

1.1 基本定义

C++ 中的结构体（struct）是一种用户自定义复合数据类型，它不仅能封装多个不同类型的成员变量（数据），还能封装操作这些数据的成员函数（行为），是面向对象编程（OOP）中 “封装” 特性的重要载体。

1.2 C++ 结构体与 C 语言结构体的核心区别

特点	C 语言结构体	C++ 结构体
成员类型	仅支持成员变量（数据）	支持成员变量 + 成员函数（数据 + 行为）
访问权限	无访问权限控制（默认公开）	支持public/private/protected（默认public）
面向对象特性	不支持（无构造 / 析构函数）	支持（构造、析构、继承、多态等）
赋值与使用	仅数据拷贝	支持对象赋值、函数调用等完整操作

1.3 C++ 结构体与类（class）的区别

C++ 中struct和class的功能几乎完全一致，唯一核心区别是默认访问权限：

struct：默认访问权限为public（成员变量 / 函数默认对外可见）
class：默认访问权限为private（成员变量 / 函数默认对外隐藏）

除此之外，两者都支持构造函数、析构函数、继承、虚函数等面向对象特性。

二、C++ 结构体的基本使用

2.1 结构体的定义

包含成员变量和成员函数：

语法格式：


struct 结构体名 {
    // 访问权限修饰符（可选，默认public）
    访问权限(public/private/protected):
        // 成员变量（数据成员）
        数据类型 成员变量1;
        数据类型 成员变量2;
        // ... 更多成员变量
        
        // 成员函数（成员方法，分为声明+实现）
        返回值类型 成员函数名1(参数列表);
        返回值类型 成员函数名2(参数列表);
        // ... 更多成员函数
};

// 结构体成员函数的外部实现（若内部仅声明）
返回值类型 结构体名::成员函数名(参数列表) {
    // 函数体（可访问结构体的成员变量）
}

示例：

定义一个描述 “学生” 的结构体（包含成员变量和成员函数）


#include <iostream>
#include <cstring>

using namespace std;

// 定义Student结构体
struct Student {
    // 成员变量（默认public，可直接访问）
    char name[20];  // 姓名
    int age;        // 年龄
    float score;    // 成绩
    
    // 成员函数：内部直接实现
    void printInfo() {
        cout << "姓名：" << name << endl;
        cout << "年龄：" << age << endl;
        cout << "成绩：" << score << endl;
    }
    
    // 成员函数：仅声明，外部实现
    void updateScore(float newScore);
    
    // 成员函数：带参数的初始化函数
    void initStudent(const char* stuName, int stuAge, float stuScore) {
        strcpy(name, stuName);
        age = stuAge;
        score = stuScore;
    }
};

// 成员函数的外部实现（必须加"结构体名::"作用域解析符）
void Student::updateScore(float newScore) {
    score = newScore;
    cout << "成绩已更新为：" << newScore << endl;
}

2.2 结构体对象的创建与初始化

C++ 支持多种结构体对象（实例）的创建和初始化方式，核心包括直接创建、构造函数初始化等。

方式 1：直接创建对象并手动赋值


#include <iostream>
#include <cstring>

using namespace std;

int main() {
    // 创建Student对象
    Student stu1;
    
    // 直接访问成员变量赋值（因默认public，可直接修改）
    strcpy(stu1.name, "张三");
    stu1.age = 18;
    stu1.score = 92.5;
    
    // 调用成员函数
    cout << "stu1信息：" << endl;
    stu1.printInfo();
    
    // 更新成绩并再次打印
    stu1.updateScore(95.0);
    cout << "更新后stu1信息：" << endl;
    stu1.printInfo();
    
    return 0;
}

方式 2：通过初始化函数批量赋值


#include <iostream>

using namespace std;

int main() {
    Student stu2;
    // 调用自定义初始化函数，批量设置成员变量
    stu2.initStudent("李四", 19, 88.0);
    
    cout << "\nstu2信息：" << endl;
    stu2.printInfo();
    return 0;
}

方式 3：构造函数初始化（推荐，C++ 面向对象特性）


#include <iostream>
#include <cstring>

using namespace std;

// 重新定义带构造函数的Student结构体
struct Student {
    // 成员变量
    char name[20];
    int age;
    float score;
    
    // 无参构造函数（默认构造函数）
    Student() {
        // 初始化默认值
        strcpy(name, "未知姓名");
        age = 0;
        score = 0.0;
        cout << "无参构造函数被调用" << endl;
    }
    
    // 有参构造函数（重载）
    Student(const char* stuName, int stuAge, float stuScore) {
        strcpy(name, stuName);
        age = stuAge;
        score = stuScore;
        cout << "有参构造函数被调用" << endl;
    }
    
    // 成员函数
    void printInfo() {
        cout << "姓名：" << name << endl;
        cout << "年龄：" << age << endl;
        cout << "成绩：" << score << endl;
    }
    
    void updateScore(float newScore) {
        score = newScore;
        cout << "成绩已更新为：" << newScore << endl;
    }
};

// 测试构造函数
int main() {
    // 调用无参构造函数创建对象
    Student stu3;
    cout << "\nstu3默认信息：" << endl;
    stu3.printInfo();
    
    // 调用有参构造函数创建对象
    Student stu4("王五", 20, 95.0);
    cout << "\nstu4初始化信息：" << endl;
    stu4.printInfo();
    
    return 0;
}

2.3 结构体成员的访问方式

根据对象的类型（普通对象 / 指针对象），使用不同的访问运算符：

场景 1：普通对象访问成员（. 成员访问运算符）

语法：对象名.成员变量名 / 对象名.成员函数名(参数)


Student stu;
stu.age = 18;  // 访问成员变量
stu.printInfo();  // 调用成员函数

场景 2：指针对象访问成员（-> 成员访问运算符）

语法：对象名.成员变量名 / 对象名.成员函数名(参数)


#include <iostream>

using namespace std;

int main() {
    // 方式1：栈区对象取地址
    Student stu5("赵六", 17, 90.0);
    Student* pStu1 = &stu5;
    
    // 通过指针访问成员
    cout << "\n指针访问stu5信息：" << endl;
    cout << "姓名：" << pStu1->name << endl;
    pStu1->updateScore(92.0);
    pStu1->printInfo();
    
    // 方式2：堆区动态创建对象（new关键字）
    Student* pStu2 = new Student("孙七", 21, 85.5);
    cout << "\n堆区对象pStu2信息：" << endl;
    pStu2->printInfo();
    
    // 释放堆区内存（避免内存泄漏）
    delete pStu2;
    pStu2 = nullptr;  // 避免野指针
    
    return 0;
}

三、C++ 结构体的进阶特性

3.1 访问权限控制（public/private/protected）

public：公有权限，结构体内外均可访问（默认权限）
private：私有权限，仅结构体内部（成员函数）可访问，外部无法直接操作
protected：保护权限，仅结构体内部和子类可访问（继承场景使用）

示例：带访问权限控制的结构体


#include <iostream>
#include <cstring>

using namespace std;

struct Student {
private:
    // 私有成员变量：外部无法直接访问
    char name[20];
    int age;
    float score;
    
public:
    // 公有成员函数：作为外部访问私有成员的接口
    Student(const char* stuName, int stuAge, float stuScore) {
        strcpy(name, stuName);
        age = stuAge;
        score = stuScore;
    }
    
    void printInfo() {
        // 内部可访问私有成员
        cout << "姓名：" << name << endl;
        cout << "年龄：" << age << endl;
        cout << "成绩：" << score << endl;
    }
    
    void setAge(int newAge) {
        // 可在函数内添加合法性校验
        if (newAge > 0 && newAge < 100) {
            age = newAge;
            cout << "年龄已更新为：" << newAge << endl;
        } else {
            cout << "无效的年龄值！" << endl;
        }
    }
    
    int getAge() {
        return age;
    }
};

int main() {
    Student stu("周八", 19, 89.0);
    stu.printInfo();
    
    // stu.age = 20;  // 错误：age是私有成员，外部无法直接访问
    stu.setAge(20);  // 正确：通过公有成员函数修改私有成员
    cout << "当前年龄：" << stu.getAge() << endl;
    
    stu.setAge(-5);  // 非法值，会被函数拦截
    return 0;
}

3.2 析构函数：资源自动释放

析构函数是与结构体同名、前缀加~的特殊成员函数，无参数、无返回值，用于对象销毁时自动释放资源（如堆区内存、文件句柄等），仅能有一个（无法重载）。


#include <iostream>
#include <cstring>

using namespace std;

struct MyString {
    // 成员变量
    char* str;  // 字符指针，指向堆区字符串
    
    // 构造函数：动态分配内存
    MyString(const char* s) {
        int len = strlen(s) + 1;
        str = new char[len];  // 堆区分配内存
        strcpy(str, s);
        cout << "构造函数：分配内存，字符串为：" << str << endl;
    }
    
    // 析构函数：释放堆区内存
    ~MyString() {
        delete[] str;  // 释放数组内存
        str = nullptr;
        cout << "析构函数：释放内存" << endl;
    }
    
    // 成员函数
    void printStr() {
        cout << "字符串内容：" << str << endl;
    }
};

int main() {
    MyString strObj("Hello C++ Struct!");
    strObj.printStr();
    
    // 对象销毁时，析构函数会自动调用，无需手动释放
    return 0;
}

3.3 结构体数组：存储多个对象

结构体数组用于批量存储同类型结构体对象，便于统一管理和遍历。


#include <iostream>

using namespace std;

int main() {
    // 定义结构体数组并通过有参构造函数初始化
    Student stuArr[3] = {
        Student("张三", 18, 92.5),
        Student("李四", 19, 88.0),
        Student("王五", 20, 95.0)
    };
    
    // 遍历结构体数组
    cout << "\n学生列表：" << endl;
    for (int i = 0; i < 3; i++) {
        cout << "\n第" << i+1 << "个学生：" << endl;
        stuArr[i].printInfo();
    }
    
    // 修改数组中对象的属性
    stuArr[1].setAge(21);
    cout << "\n修改后第2个学生年龄：" << stuArr[1].getAge() << endl;
    
    return 0;
}

3.4 结构体作为函数参数 / 返回值

C++ 支持结构体对象作为函数的参数和返回值，推荐使用指针或引用传递（避免对象拷贝的性能开销）。

场景 1：结构体对象作为参数（值传递）


#include <iostream>

using namespace std;

// 值传递：会拷贝整个对象
void printStudent(Student stu) {
    cout << "\n函数内打印学生信息：" << endl;
    stu.printInfo();
}

int main() {
    Student stu("赵六", 17, 90.0);
    printStudent(stu);
    return 0;
}

场景 2：结构体指针 / 引用作为参数（高效传递）


#include <iostream>
#include <cstring>

using namespace std;

// 引用传递：直接操作原对象，无拷贝开销
void updateStudentScore(Student& stu, float newScore) {
    stu.updateScore(newScore);
}

// 指针传递：同样无拷贝开销
void printStudentByPtr(Student* pStu) {
    cout << "\n指针传递打印学生信息：" << endl;
    pStu->printInfo();
}

int main() {
    Student stu("孙七", 21, 85.5);
    updateStudentScore(stu, 89.0);
    printStudentByPtr(&stu);
    return 0;
}

场景 3：结构体作为函数返回值


#include <iostream>

using namespace std;

// 返回结构体对象
Student createStudent(const char* name, int age, float score) {
    return Student(name, age, score);
}

int main() {
    Student stu = createStudent("周八", 19, 88.0);
    cout << "\n创建的学生信息：" << endl;
    stu.printInfo();
    return 0;
}

3.5 自引用结构体：构建链式数据结构

自引用结构体是指结构体内部包含一个指向自身结构体类型的指针成员，是实现链表、树、图等链式/层级数据结构的核心基础。

💡 核心原理：

不能直接在结构体中定义自身类型的成员变量（会导致无限递归定义，编译器无法确定结构体大小），但可以定义自身类型的指针（指针大小固定，仅占4/8字节）。

1. 自引用结构体的定义（以单向链表节点为例）


// 定义单向链表节点的自引用结构体
struct ListNode {
    // 数据域：存储节点数据
    int val;          
    // 指针域：指向同类型结构体的指针（自引用核心）
    ListNode* next;   

    // 构造函数（简化初始化）
    ListNode(int value) : val(value), next(nullptr) {
        cout << "节点创建，值为：" << val << endl;
    }

    // 析构函数：释放后续节点内存（避免内存泄漏）
    ~ListNode() {
        cout << "节点销毁，值为：" << val << endl;
        // 递归释放后续节点
        if (next != nullptr) {
            delete next;
            next = nullptr;
        }
    }

    // 成员函数：遍历链表并打印
    void printList() {
        ListNode* current = this; // 从当前节点开始遍历
        while (current != nullptr) {
            cout << current->val << " -> ";
            current = current->next;
        }
        cout << "nullptr" << endl;
    }

    // 成员函数：在链表尾部添加新节点
    void addNode(int value) {
        ListNode* current = this;
        // 找到链表最后一个节点
        while (current->next != nullptr) {
            current = current->next;
        }
        // 创建新节点并挂载到尾部
        current->next = new ListNode(value);
    }
};

2. 自引用结构体的使用示例（构建单向链表）


#include <iostream>

using namespace std;

int main() {
    // 1. 创建链表头节点
    ListNode* head = new ListNode(10);

    // 2. 向链表尾部添加节点
    head->addNode(20);
    head->addNode(30);
    head->addNode(40);

    // 3. 遍历并打印链表
    cout << "链表内容：";
    head->printList();

    // 4. 修改节点数据
    head->next->val = 25; // 修改第二个节点的值
    cout << "修改后链表：";
    head->printList();

    // 5. 释放链表内存（析构函数会递归释放所有节点）
    delete head;
    head = nullptr;

    return 0;
}

3. 自引用结构体的典型应用场景

单向链表/双向链表：双向链表需额外定义 `ListNode* prev` 指向前驱节点；
二叉树节点：包含左孩子、右孩子指针（`TreeNode* left; TreeNode* right;`）；
图的邻接表：每个顶点对应一个链表，存储相邻顶点；
栈/队列的链式实现：替代数组实现动态扩容的栈/队列。

4. 注意事项

自引用结构体必须使用指针而非普通对象（否则编译器无法计算结构体大小）；
动态创建的自引用结构体对象，需手动释放内存（建议在析构函数中递归释放，避免内存泄漏）；
避免出现“循环引用”（如A->next=B，B->next=A），否则析构时会无限递归，需手动打断循环；
可结合智能指针（`std::unique_ptr`/`std::shared_ptr`）替代裸指针，简化内存管理。

四、C++ 结构体的典型应用场景

描述复杂实体对象：如学生、员工、商品、汽车等具有多个属性的实体，通过成员变量存储属性，成员函数封装行为（如成绩更新、薪资计算）；
数据批量管理：利用结构体数组存储多个同类型对象（如班级学生列表、商品清单），便于遍历、查询和修改；
底层数据结构实现：用于实现链表、栈、队列等数据结构（如链表节点结构体包含数据域和指针域，成员函数封装节点插入 / 删除逻辑）；
网络编程 / 硬件编程：封装网络报文头、寄存器配置等复杂数据结构，通过成员函数实现数据的打包 / 解包、配置初始化；
业务逻辑封装：将相关的数据和操作封装为结构体，提高代码的可维护性和复用性（如订单结构体包含订单信息和订单处理函数）。

五、注意事项

作用域解析符::：结构体成员函数外部实现时，必须添加结构体名::，明确函数所属的结构体；
构造函数重载：可定义多个参数列表不同的构造函数，满足不同的初始化需求，但无参构造函数若被显式定义，编译器不会自动生成默认构造函数；
堆区对象内存管理：使用new创建的结构体对象，必须用delete（单个对象）/delete[]（对象数组）释放，避免内存泄漏；
访问权限设计：建议将成员变量设为private，通过public成员函数（get/set 方法）访问和修改，增强封装性和数据安全性；
避免对象拷贝开销：当结构体体积较大时，优先使用指针或引用传递，而非值传递；
析构函数的必要性：若结构体包含堆区内存、文件句柄等资源，必须显式定义析构函数释放资源，避免资源泄漏；
自引用结构体：仅能包含自身类型的指针成员，不可包含普通对象；动态创建的自引用对象需递归释放内存，避免循环引用导致的内存泄漏。

六、总结

C++ 结构体支持成员变量（数据）和成员函数（行为），是面向对象封装特性的重要载体，默认访问权限为public；
结构体对象的访问方式：普通对象用.，指针对象用->；成员函数外部实现需加::作用域解析符；
核心特性包括构造函数（初始化）、析构函数（资源释放）、访问权限控制、结构体数组、函数参数 / 返回值传递；
自引用结构体是实现链表、树等链式数据结构的核心，通过自身类型的指针成员构建节点间的关联关系；
与class的唯一区别是默认访问权限，功能上完全一致；
应用场景涵盖复杂对象描述、数据批量管理、数据结构实现等，是 C++ 编程的核心知识点之一。

本教程从 C++ 结构体的特性、定义、使用到进阶技巧，全面拆解 C++ 结构体的核心用法。掌握结构体的运用，是学习数据结构的重要基础之一。

返回顶部